/////////////////////////////////////////////////////////////////////////////
//
//! @file    mip_sdk_ahrs.c
//! @author  Nathan Miller
//! @version 1.1
//
//! @description MIP AHRS Descriptor Set Definition File
//
// External dependencies:
//
//  mip.h
//
//!@copyright 2014 Lord Microstrain Sensing Systems.
//
//!@section CHANGES
//!
//
//!@section LICENSE
//!
//! THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING
//! CUSTOMERS WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER
//! FOR THEM TO SAVE TIME. AS A RESULT, LORD MICROSTRAIN SENSING SYSTEMS
//! SHALL NOT BE HELD LIABLE FOR ANY DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES
//! WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT OF SUCH SOFTWARE AND/OR
//! THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION CONTAINED HEREIN IN CONNECTION
//! WITH THEIR PRODUCTS.
//
/////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
//
// Include Files
//
////////////////////////////////////////////////////////////////////////////////

#include "mip_sdk_ahrs.h"
#include "byteswap_utilities.h"

/////////////////////////////////////////////////////////////////////////////
//
//! @fn
//! void mip_ahrs_raw_accel_byteswap(mip_ahrs_raw_accel *raw_accel)
//
//! @section DESCRIPTION
//! Byteswap an AHRS Raw Accel Structure.
//
//! @section DETAILS
//!
//! @param [in] mip_ahrs_raw_accel *raw_accel - The structure to be byteswapped.
//
//! @section NOTES
//!
//! None
//
/////////////////////////////////////////////////////////////////////////////

void mip_ahrs_raw_accel_byteswap(mip_ahrs_raw_accel* raw_accel) {
  u8 i;

  for (i = 0; i < 3; i++) byteswap_inplace(&raw_accel->raw_accel[i], sizeof(float));
}

/////////////////////////////////////////////////////////////////////////////
//
//! @fn
//! void mip_ahrs_raw_gyro_byteswap(mip_ahrs_raw_gyro *raw_gyro)
//
//! @section DESCRIPTION
//! Byteswap an AHRS Raw Gyro Structure.
//
//! @section DETAILS
//!
//! @param [in] mip_ahrs_raw_gyro *raw_gyro - The structure to be byteswapped.
//
//! @section NOTES
//!
//! None
//
/////////////////////////////////////////////////////////////////////////////

void mip_ahrs_raw_gyro_byteswap(mip_ahrs_raw_gyro* raw_gyro) {
  u8 i;

  for (i = 0; i < 3; i++) byteswap_inplace(&raw_gyro->raw_gyro[i], sizeof(float));
}

/////////////////////////////////////////////////////////////////////////////
//
//! @fn
//! void mip_ahrs_raw_mag_byteswap(mip_ahrs_raw_mag *raw_mag)
//
//! @section DESCRIPTION
//! Byteswap an AHRS Raw Mag Structure.
//
//! @section DETAILS
//!
//! @param [in] mip_ahrs_raw_mag *raw_mag - The structure to be byteswapped.
//
//! @section NOTES
//!
//! None
//
/////////////////////////////////////////////////////////////////////////////

void mip_ahrs_raw_mag_byteswap(mip_ahrs_raw_mag* raw_mag) {
  u8 i;

  for (i = 0; i < 3; i++) byteswap_inplace(&raw_mag->raw_mag[i], sizeof(float));
}

/////////////////////////////////////////////////////////////////////////////
//
//! @fn
//! void mip_ahrs_scaled_accel_byteswap(mip_ahrs_scaled_accel *scaled_accel)
//
//! @section DESCRIPTION
//! Byteswap an AHRS Scaled Accel Structure.
//
//! @section DETAILS
//!
//! @param [in] mip_ahrs_scaled_accel *scaled_accel - The structure to be byteswapped.
//
//! @section NOTES
//!
//! None
//
/////////////////////////////////////////////////////////////////////////////

void mip_ahrs_scaled_accel_byteswap(mip_ahrs_scaled_accel* scaled_accel) {
  u8 i;

  for (i = 0; i < 3; i++) byteswap_inplace(&scaled_accel->scaled_accel[i], sizeof(float));
}

/////////////////////////////////////////////////////////////////////////////
//
//! @fn
//! void mip_ahrs_scaled_gyro_byteswap(mip_ahrs_scaled_gyro *scaled_gyro)
//
//! @section DESCRIPTION
//! Byteswap an AHRS Scaled Gyro Structure.
//
//! @section DETAILS
//!
//! @param [in] mip_ahrs_scaled_gyro *scaled_gyro - The structure to be byteswapped.
//
//! @section NOTES
//!
//! None
//
/////////////////////////////////////////////////////////////////////////////

void mip_ahrs_scaled_gyro_byteswap(mip_ahrs_scaled_gyro* scaled_gyro) {
  u8 i;

  for (i = 0; i < 3; i++) byteswap_inplace(&scaled_gyro->scaled_gyro[i], sizeof(float));
}

/////////////////////////////////////////////////////////////////////////////
//
//! @fn
//! void mip_ahrs_scaled_mag_byteswap(mip_ahrs_scaled_mag *scaled_mag)
//
//! @section DESCRIPTION
//! Byteswap an AHRS Scaled Mag Structure.
//
//! @section DETAILS
//!
//! @param [in] mip_ahrs_scaled_mag *scaled_mag - The structure to be byteswapped.
//
//! @section NOTES
//!
//! None
//
/////////////////////////////////////////////////////////////////////////////

void mip_ahrs_scaled_mag_byteswap(mip_ahrs_scaled_mag* scaled_mag) {
  u8 i;

  for (i = 0; i < 3; i++) byteswap_inplace(&scaled_mag->scaled_mag[i], sizeof(float));
}

/////////////////////////////////////////////////////////////////////////////
//
//! @fn
//! void mip_ahrs_delta_theta_byteswap(mip_ahrs_delta_theta *delta_theta)
//
//! @section DESCRIPTION
//! Byteswap an AHRS Delta Theta Structure.
//
//! @section DETAILS
//!
//! @param [in] mip_ahrs_delta_theta *delta_theta - The structure to be byteswapped.
//
//! @section NOTES
//!
//! None
//
/////////////////////////////////////////////////////////////////////////////

void mip_ahrs_delta_theta_byteswap(mip_ahrs_delta_theta* delta_theta) {
  u8 i;

  for (i = 0; i < 3; i++) byteswap_inplace(&delta_theta->delta_theta[i], sizeof(float));
}

/////////////////////////////////////////////////////////////////////////////
//
//! @fn
//! void mip_ahrs_delta_velocity_byteswap(mip_ahrs_delta_velocity *delta_velocity)
//
//! @section DESCRIPTION
//! Byteswap an AHRS Delta Velocity Structure.
//
//! @section DETAILS
//!
//! @param [in] mip_ahrs_delta_velocity *delta_velocity - The structure to be byteswapped.
//
//! @section NOTES
//!
//! None
//
/////////////////////////////////////////////////////////////////////////////

void mip_ahrs_delta_velocity_byteswap(mip_ahrs_delta_velocity* delta_velocity) {
  u8 i;

  for (i = 0; i < 3; i++) byteswap_inplace(&delta_velocity->delta_velocity[i], sizeof(float));
}

/////////////////////////////////////////////////////////////////////////////
//
//! @fn
//! void mip_ahrs_orientation_matrix_byteswap(mip_ahrs_orientation_matrix *orientation_matrix)
//
//! @section DESCRIPTION
//! Byteswap an AHRS Orientation Matrix Structure.
//
//! @section DETAILS
//!
//! @param [in] mip_ahrs_orientation_matrix *orientation_matrix - The structure to be byteswapped.
//
//! @section NOTES
//!
//! None
//
/////////////////////////////////////////////////////////////////////////////

void mip_ahrs_orientation_matrix_byteswap(mip_ahrs_orientation_matrix* orientation_matrix) {
  u8 i, j;

  for (i = 0; i < 3; i++) {
    for (j = 0; j < 3; j++) byteswap_inplace(&orientation_matrix->m[i][j], sizeof(float));
  }
}

/////////////////////////////////////////////////////////////////////////////
//
//! @fn
//! void mip_ahrs_quaternion_byteswap(mip_ahrs_quaternion *quaternion)
//
//! @section DESCRIPTION
//! Byteswap an AHRS Quaternion Structure.
//
//! @section DETAILS
//!
//! @param [in] mip_ahrs_quaternion *quaternion - The structure to be byteswapped.
//
//! @section NOTES
//!
//! None
//
/////////////////////////////////////////////////////////////////////////////

void mip_ahrs_quaternion_byteswap(mip_ahrs_quaternion* quaternion) {
  u8 i;

  for (i = 0; i < 4; i++) byteswap_inplace(&quaternion->q[i], sizeof(float));
}

/////////////////////////////////////////////////////////////////////////////
//
//! @fn
//! void mip_ahrs_euler_angles_byteswap(mip_ahrs_euler_angles *euler_angles)
//
//! @section DESCRIPTION
//! Byteswap an AHRS Euler Angle Structure.
//
//! @section DETAILS
//!
//! @param [in] mip_ahrs_euler_angles *euler_angles - The structure to be byteswapped.
//
//! @section NOTES
//!
//! None
//
/////////////////////////////////////////////////////////////////////////////

void mip_ahrs_euler_angles_byteswap(mip_ahrs_euler_angles* euler_angles) {
  byteswap_inplace(&euler_angles->roll, sizeof(float));
  byteswap_inplace(&euler_angles->pitch, sizeof(float));
  byteswap_inplace(&euler_angles->yaw, sizeof(float));
}

/////////////////////////////////////////////////////////////////////////////
//
//! @fn
//! void mip_ahrs_orientation_update_matrix_byteswap(mip_ahrs_orientation_update_matrix *orientation_update_matrix)
//
//! @section DESCRIPTION
//! Byteswap an AHRS Orientation Update Matrix Structure.
//
//! @section DETAILS
//!
//! @param [in] mip_ahrs_orientation_update_matrix *orientation_update_matrix - The structure to be byteswapped.
//
//! @section NOTES
//!
//! None
//
/////////////////////////////////////////////////////////////////////////////

void mip_ahrs_orientation_update_matrix_byteswap(mip_ahrs_orientation_update_matrix* orientation_update_matrix) {
  u8 i, j;

  for (i = 0; i < 3; i++) {
    for (j = 0; j < 3; j++) byteswap_inplace(&orientation_update_matrix->m[i][j], sizeof(float));
  }
}

/////////////////////////////////////////////////////////////////////////////
//
//! @fn
//! void mip_ahrs_raw_temp_byteswap(mip_ahrs_raw_temp *raw_temp)
//
//! @section DESCRIPTION
//! Byteswap an AHRS Raw Temp Structure.
//
//! @section DETAILS
//!
//! @param [in] mip_ahrs_raw_temp *raw_temp - The structure to be byteswapped.
//
//! @section NOTES
//!
//! None
//
/////////////////////////////////////////////////////////////////////////////

void mip_ahrs_raw_temp_byteswap(mip_ahrs_raw_temp* raw_temp) {
  u8 i;

  for (i = 0; i < 4; i++) byteswap_inplace(&raw_temp->raw_temp, sizeof(u16));
}

/////////////////////////////////////////////////////////////////////////////
//
//! @fn
//! void mip_ahrs_internal_timestamp_byteswap(mip_ahrs_internal_timestamp *internal_timestamp)
//
//! @section DESCRIPTION
//! Byteswap an AHRS Internal Timestamp Structure.
//
//! @section DETAILS
//!
//! @param [in] mip_ahrs_internal_timestamp *internal_timestamp - The structure to be byteswapped.
//
//! @section NOTES
//!
//! None
//
/////////////////////////////////////////////////////////////////////////////

void mip_ahrs_internal_timestamp_byteswap(mip_ahrs_internal_timestamp* internal_timestamp) {
  byteswap_inplace(&internal_timestamp->counts, sizeof(u32));
}

/////////////////////////////////////////////////////////////////////////////
//
//! @fn
//! void mip_ahrs_1pps_timestamp_byteswap(mip_ahrs_1pps_timestamp *pps_timestamp)
//
//! @section DESCRIPTION
//! Byteswap an AHRS 1PPS Timestamp Structure.
//
//! @section DETAILS
//!
//! @param [in] mip_ahrs_1pps_timestamp *pps_timestamp - The structure to be byteswapped.
//
//! @section NOTES
//!
//! None
//
/////////////////////////////////////////////////////////////////////////////

void mip_ahrs_1pps_timestamp_byteswap(mip_ahrs_1pps_timestamp* pps_timestamp) {
  byteswap_inplace(&pps_timestamp->seconds, sizeof(u32));
  byteswap_inplace(&pps_timestamp->nanoseconds, sizeof(u32));
}

/////////////////////////////////////////////////////////////////////////////
//
//! @fn
//! void mip_ahrs_gps_timestamp_byteswap(mip_ahrs_gps_timestamp *gps_timestamp)
//
//! @section DESCRIPTION
//! Byteswap an AHRS GPS Timestamp Structure.
//
//! @section DETAILS
//!
//! @param [in] mip_ahrs_gps_timestamp *gps_timestamp - The structure to be byteswapped.
//
//! @section NOTES
//!
//! None
//
/////////////////////////////////////////////////////////////////////////////

void mip_ahrs_gps_timestamp_byteswap(mip_ahrs_gps_timestamp* gps_timestamp) {
  byteswap_inplace(&gps_timestamp->tow, sizeof(double));
  byteswap_inplace(&gps_timestamp->week_number, sizeof(u16));
  byteswap_inplace(&gps_timestamp->valid_flags, sizeof(u16));
}

/////////////////////////////////////////////////////////////////////////////
//
//! @fn
//! void mip_ahrs_up_vector_byteswap(mip_ahrs_up_vector *up_vector)
//
//! @section DESCRIPTION
//! Byteswap an AHRS Up Vector Structure.
//
//! @section DETAILS
//!
//! @param [in] mip_ahrs_up_vector *up_vector - The structure to be byteswapped.
//
//! @section NOTES
//!
//! None
//
/////////////////////////////////////////////////////////////////////////////

void mip_ahrs_up_vector_byteswap(mip_ahrs_up_vector* up_vector) {
  u8 i;

  for (i = 0; i < 3; i++) byteswap_inplace(&up_vector->up, sizeof(float));
}

/////////////////////////////////////////////////////////////////////////////
//
//! @fn
//! void mip_ahrs_north_vector_byteswap(mip_ahrs_north_vector *north_vector)
//
//! @section DESCRIPTION
//! Byteswap an AHRS North Vector Structure.
//
//! @section DETAILS
//!
//! @param [in] mip_ahrs_north_vector *north_vector - The structure to be byteswapped.
//
//! @section NOTES
//!
//! None
//
/////////////////////////////////////////////////////////////////////////////

void mip_ahrs_north_vector_byteswap(mip_ahrs_north_vector* north_vector) {
  u8 i;

  for (i = 0; i < 3; i++) byteswap_inplace(&north_vector->north, sizeof(float));
}

/////////////////////////////////////////////////////////////////////////////
//
//! @fn
//! void mip_ahrs_signal_settings_byteswap(mip_ahrs_signal_settings *signal_settings)
//
//! @section DESCRIPTION
//! Byteswap an AHRS signal conditioning Structure.
//
//! @section DETAILS
//!
//! @param [in] mip_ahrs_signal_settings *signal_settings - The structure to be byteswapped.
//
//! @section NOTES
//!
//! None
//
/////////////////////////////////////////////////////////////////////////////

void mip_ahrs_signal_settings_byteswap(mip_ahrs_signal_settings* signal_settings) {
  byteswap_inplace(&signal_settings->orientation_decimation, sizeof(u16));
  byteswap_inplace(&signal_settings->data_conditioning_flags, sizeof(u16));
  byteswap_inplace(&signal_settings->up_compensation, sizeof(u16));
  byteswap_inplace(&signal_settings->north_compensation, sizeof(u16));
  byteswap_inplace(&signal_settings->reserved, sizeof(u16));
}
